ECE5725: Arcade Console with a Vending Machine Full of Prizes!

Code Appendix - GitHub

 Arcade Code
import subprocess
import shlex
from time import sleep
import io
 
# rfid libs
import board
import busio
from digitalio import DigitalInOut
from adafruit_pn532.adafruit_pn532 import MIFARE_CMD_AUTH_B
from adafruit_pn532.spi import PN532_SPI
 
# SPI connection:
spi = busio.SPI(board.SCK_1, MOSI = board.MOSI_1, MISO =  board.MISO_1)
cs_pin = DigitalInOut(board.D16)
pn532 = PN532_SPI(spi, cs_pin, debug=False)
# Configure PN532 to communicate with MiFare cards
pn532.SAM_configuration()
 
NOTHING = 0
PACMAN = 1
SPACE = 2
GALA = 3
 
def display(char):
    global process
    buffer = process.stdout.read1(char).decode("utf-8")
    # print(buffer, end="", flush=True)
    return buffer
 
def search_for_output(string):
    global process
    buffer = ""
    while not (string in buffer):
        buffer = buffer + display(1)
    display(-1)
 
def runraw(command, resp):
    global process
    process.stdin.write(bytes(command + "\n", 'utf-8'))
    # print(command)
    process.stdin.flush()
    sleep(.16)
    string = display(-1)
    if resp:
        return string.split('\n')[0]
 
def run(command, resp):
    if resp:
        return int(runraw(command, resp))
    else:
        runraw(command, resp)
       
def death():
    global game
   
    run("emu.pause()", False)
    score = 0
 
    if game == PACMAN:
        temp = run("print(mem:read_u8(0xee83))", True)
        score *= 100
        score += (temp >> 4) * 10
        score += temp & 0xF
        temp = run("print(mem:read_u8(0xee82))", True)
        score *= 100
        score += (temp >> 4) * 10
        score += temp & 0xF
        sleep(0.16)
        score *= 100
        temp = run("print(mem:read_u8(0xee81))", True)
        score += (temp >> 4) * 10
        score += temp & 0xF
        sleep(0.16)
        score *= 100
        temp = run("print(mem:read_u8(0xee80))", True)
        score += (temp >> 4) * 10
        score += temp & 0xF
 
        score /= 10	# point --> ticket scaling
        score = int(score)
 
    if game == SPACE:
        temp = run("print(mem:read_u8(0x20f8))", True)
        score *= 100
        score += (temp >> 4) * 10
        score += temp & 0xF
        sleep(0.16)
        score *= 100
        temp = run("print(mem:read_u8(0x20f7))", True)
        score += (temp >> 4) * 10
        score += temp & 0xF
        sleep(0.16)
        score *= 100
        temp = run("print(mem:read_u8(0x20f6))", True)
        score += (temp >> 4) * 10
        score += temp & 0xF
 
    if game == GALA:
        score *= 10
        temp = run("print(mem:read_u8(0x83FF))", True)
        if temp != 36:
            score += temp
        sleep(0.16)
       
        score *= 10
        temp = run("print(mem:read_u8(0x83FE))", True)
        if temp != 36:
            score += temp
        sleep(0.16)
 
        score *= 10
        temp = run("print(mem:read_u8(0x83FD))", True)
        if temp != 36:
            score += temp
        sleep(0.16)
 
        score *= 10
        temp = run("print(mem:read_u8(0x83FC))", True)
        if temp != 36:
            score += temp
        sleep(0.16)
 
        score *= 10
        temp = run("print(mem:read_u8(0x83FB))", True)
        if temp != 36:
            score += temp
        sleep(0.16)
 
        score *= 10
        temp = run("print(mem:read_u8(0x83FA))", True)
        if temp != 36:
            score += temp
        sleep(0.16)
 
        score *= 10
        temp = run("print(mem:read_u8(0x83F9))", True)
        if temp != 36:
            score += temp
        sleep(0.16)
 
        score *= 10
        temp = run("print(mem:read_u8(0x83F8))", True)
        if temp != 36:
            score += temp
        sleep(0.16)
 
    # print("score: " + str(score))
 
    key = b"\xFF\xFF\xFF\xFF\xFF\xFF"
    uid = None
    authenticated = False
    check = False
    while not check:
        try:
            while uid is None:
                # display message
                run("manager.machine:popmessage('tap card to collect your " + str(score) + " tickets')", False)
                # Check if a card is available to read
                uid = pn532.read_passive_target(timeout=2)
 
            authenticated = pn532.mifare_classic_authenticate_block(uid, 4, MIFARE_CMD_AUTH_B, key)
            if not authenticated:
                run("manager.machine:popmessage('tap card again')", False)
                uid = None
           
            # read points on card
            cardpoints = int.from_bytes(pn532.mifare_classic_read_block(4), "big")
            # write new points to card
            newpoints = score + cardpoints
            data = newpoints.to_bytes(16, 'big')
            pn532.mifare_classic_write_block(4, data)
            # confirm points from card
            check = int.from_bytes(pn532.mifare_classic_read_block(4), "big") == newpoints
 
        except:
            authenticated = False
            uid = None
            check = False
            run("Try scanning again", False)
 
    run("manager.machine:popmessage('you had " + str(cardpoints) + " tickets you now have " + str(newpoints) + " tickets!')", False)
 
    sleep(2)
    run("emu.unpause()", False)
 
alive = False
with subprocess.Popen(
    shlex.split("mame -console -nodebug -skip_gameinfo"),
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
) as process:
    sleep(1)
    display(-1)
 
    while(True):
        rom = runraw("print(emu.romname())", True)
        if rom == "pacman":
            if game != PACMAN:
                alive = False
                sleep(10)
                run("cpu = manager.machine.devices[':maincpu']", False)
                sleep(1)
                run("mem = cpu.spaces['program']", False)
                sleep(1)
                run("s = manager.machine.screens[':screen']", False)
                game = PACMAN
        elif rom == "invaderl":
            if game != SPACE:
                alive = False
                sleep(10)
                run("cpu = manager.machine.devices[':maincpu']", False)
                sleep(1)
                run("mem = cpu.spaces['program']", False)
                sleep(1)
                run("s = manager.machine.screens[':screen']", False)
                game = SPACE
        elif rom == "galagao":
            if game != GALA:
                alive = False
                sleep(10)
                run("cpu = manager.machine.devices[':maincpu']", False)
                sleep(1)
                run("mem = cpu.spaces['program']", False)
                sleep(1)
                run("s = manager.machine.screens[':screen']", False)
                game = GALA
        else:
            game = NOTHING
       
        if game == PACMAN:
            lives = run("print(mem:read_u8(0x4e14))", True)
            if lives == 3:
                alive = True
            if lives == 0 and alive:
                alive = False
                death()
 
        if game == SPACE:
            lives = run("print(mem:read_u8(0x20ef))", True)
            if lives == 1:
                alive = True
            if lives == 0 and alive:
                alive = False
                death()
       
        if game == GALA:
            lives = run("print(mem:read_u8(0x9820))", True)
            if lives == 2:
                alive = True
            if lives == 255 and alive:
                alive = False
                death()
 
        sleep(.5)

 Vending Machine Code
# code for vending machine operation
import pygame     # Import pygame graphics library
from pygame.locals import *
import RPi.GPIO as GPIO
import time
import sys
import os
import sys
# import csv
import math
import board
import busio

# Additional import needed for I2C/SPI
from digitalio import DigitalInOut
from adafruit_pn532.adafruit_pn532 import MIFARE_CMD_AUTH_B

from adafruit_pn532.spi import PN532_SPI

# costs of items
cost = [2000,5000,10000000,800]

# motor config
unstall = True
spintime = .9
A1pwr = 20
A2pwr = 9
B1pwr = 7
B2pwr = 10

# SPI connection:
spi = busio.SPI(board.SCK_1, MOSI = board.MOSI_1, MISO =  board.MISO_1)
cs_pin = DigitalInOut(board.D16)
pn532 = PN532_SPI(spi, cs_pin, debug=False)

# Configure PN532 to communicate with MiFare cards
pn532.SAM_configuration()

key = b"\xFF\xFF\xFF\xFF\xFF\xFF"

# motor pins
DIRA1 = 26
DIRB1 = 13
DIRA2 = 6
DIRB2 = 5
PWM = 12

GPIO.setmode(GPIO.BCM)

# Setup motor pins
GPIO.setup(DIRA1, GPIO.OUT) # DIRA1
GPIO.setup(DIRB1, GPIO.OUT) # DIRA2
GPIO.setup(DIRA2, GPIO.OUT) # DIRB1
GPIO.setup(DIRB2, GPIO.OUT) # DIRB2
GPIO.setup(PWM,  GPIO.OUT) # PWMA
PWM = GPIO.PWM(PWM, 1000)


def A1_stop():   # Item A1 stop
    GPIO.output(DIRA1, GPIO.LOW)
    PWM.start(0)
def B1_stop():   # Item B1 stop
    GPIO.output(DIRB1, GPIO.LOW)
    PWM.start(0)
def A2_stop():   # Item A2 Stop
    GPIO.output(DIRA2, GPIO.LOW)
    PWM.start(0)
def B2_stop():   # Item B2 Stop
    GPIO.output(DIRB2, GPIO.LOW)
    PWM.start(0)
def stopAll():
    A1_stop()
    A2_stop()
    B1_stop()
    B2_stop()
def A1(pwr):   # A1 Dispense
    GPIO.output(DIRA1, GPIO.HIGH)
    PWM.start(pwr)
def B1(pwr):   # B1 Dispense
    GPIO.output(DIRB1, GPIO.HIGH)
    PWM.start(pwr)
def A2(pwr):   # A2 Dispense
    GPIO.output(DIRA2, GPIO.HIGH)
    PWM.start(pwr)
def B2(pwr):   # B2 Dispense
    GPIO.output(DIRB2, GPIO.HIGH)
    PWM.start(pwr)

os.putenv('SDL_VIDEODRIVER', 'fbcon') # Display on piTFT
os.putenv('SDL_FBDEV', '/dev/fb1') #
os.putenv('SDL_MOUSEDRV', 'TSLIB') # Track mouse clicks on piTFT
os.putenv('SDL_MOUSEDEV', '/dev/input/touchscreen')

# TFT buttons
def GPIO17_callback(channel):
    GPIO.cleanup()
    sys.exit()
GPIO.setup(17, GPIO.IN, pull_up_down = GPIO.PUD_UP)
GPIO.add_event_detect(17, GPIO.FALLING, callback=GPIO17_callback, bouncetime=100) 


pygame.init()
pygame.mouse.set_visible(False)
size = 240,320
black = 0, 0, 0
gray = 100, 100, 100
white = 255, 255, 255
red = 255, 0, 0
screen = pygame.display.set_mode(size)
my_font = pygame.font.Font(None, 40)
message_font = pygame.font.Font(None, 30)

# Read for reference: https://pygame-zero.readthedocs.io/en/stable/ptext.html
# create buttons
my_buttons = {  'A':( 50,  220 ),   'B':( 50, 300 ),
                '1':( 120,  220 ),   '2':( 120, 300 ),
              'CLR':( 190,  220 ), 'SEL':( 190, 300 )}
rects = []
surface = []
for my_text, text_pos in my_buttons.items():
    text_surface = my_font.render(my_text, False, black)
    rect = text_surface.get_rect(center=text_pos)
    # rect.inflate(100,100)
    screen.blit(text_surface, rect)
    surface.append(text_surface)
    rects.append(rect)

# keeps track of messages
state = 0
code = ["_", "_"]
i=0
tickets = 0
message = "Scan card or pick item"
ticketStr = "No card scanned"
popUp = " "
item = 0
canSelect = 1
clock = pygame.time.Clock()
end_time = time.time() + 120
while (True):

    screen.fill(white)               # Erase the Work space
    for i in range(len(rects)):
        screen.blit(surface[i], rects[i])
    # Create textpad msg
    num_surface = my_font.render(('sel: ' + code[0] + ' ' + code[1]), True, black)
    num_rect = num_surface.get_rect(center=(60, 180))
    screen.blit(num_surface, num_rect)

    num_surface = message_font.render((ticketStr), True, black)
    num_rect = num_surface.get_rect(center=(120, 40))
    screen.blit(num_surface, num_rect)

    num_surface = message_font.render((message), True, black)
    num_rect = num_surface.get_rect(center=(120, 100))
    screen.blit(num_surface, num_rect)

    num_surface = my_font.render((popUp), True, red)
    num_rect = num_surface.get_rect(center=(120, 150))
    screen.blit(num_surface, num_rect)

    if state == 0:
        message = "Scan card or pick item"
        ticketStr = "No card scanned"
        popUp = " "
        stopAll()
        item = 0
        canSelect = 1
        uid = None
        #RFID read here if read tickets == read
        # Check if a card is available to read
        uid = pn532.read_passive_target(timeout=1)
        if uid is not None:
            try:
                authenticated = pn532.mifare_classic_authenticate_block(uid, 4, MIFARE_CMD_AUTH_B, key)
                tickets = int.from_bytes(pn532.mifare_classic_read_block(4), "big")
                state = 1
                state1start = time.time()
            except:
                uid = None
                print("except")

    elif state == 1:
        popUp = " "
        ticketStr = "You have " + str(tickets) + " tickets"
        canSelect = 1
        if time.time() > (state1start + 5):
            uid = pn532.read_passive_target(timeout=1)
            if uid is not None:
                try:
                    authenticated = pn532.mifare_classic_authenticate_block(uid, 4, MIFARE_CMD_AUTH_B, key)
                    tickets = int.from_bytes(pn532.mifare_classic_read_block(4), "big")
                    state = 1
                    state1start = time.time()
                except:
                    uid = None
                    print("exception")
        if (time.time() >= state1start + 20):
            state = 0

    elif state == 2:
        popUp = "SCAN CARD"
        canSelect = 0
        if (time.time() >= state2start + 5):
            state = 0
        uid = pn532.read_passive_target(timeout=1)
        if uid is not None:
            try:
                authenticated = pn532.mifare_classic_authenticate_block(uid, 4, MIFARE_CMD_AUTH_B, key)
                vend_tickets = int.from_bytes(pn532.mifare_classic_read_block(4), "big")
                new_val = vend_tickets - cost[item-1]
                if new_val >= 0:
                    data = new_val.to_bytes(16, 'big')
                    pn532.mifare_classic_write_block(4, data)
                    ticketStr = "You now have " + str(new_val) + " tickets"
                    state = 4
                    state4start = time.time() 
                else:
                    state = 3
                    state3start = time.time()
            except:
                uid = None
                print("exception")

    elif state == 3:
        popUp = " "
        canSelect = 0
        message = "Too few tickets"
        if (time.time() >= state3start + 3):
            state = 0

    elif state == 4:
        popUp = "VENDING"
        canSelect = 0
        if (time.time() >= state4start + spintime):
            state = 0
        if item == 1:
            if unstall:
                A1(100)
                time.sleep(.05)
            A1(A1pwr)
        elif item == 2:
            if unstall:
                A2(70)
                time.sleep(.05)
            A2(A2pwr)
        elif item == 3:
            if unstall:
                B1(100)
                time.sleep(.05)
            B1(B1pwr)
        elif item == 4:
            if unstall:
                B2(70)
                time.sleep(.05)
            B2(B2pwr)

    if canSelect == 1:

        for event in pygame.event.get():
            if(event.type is MOUSEBUTTONUP):
                x,y = pygame.mouse.get_pos()
                pos = pygame.mouse.get_pos()
                print(pos)

                if x >= 175 and x <= 205 and y >= 80 and y <= 115:
                    print("A")
                    print(code[0] + code[1])
                    if (code[0] == "_") :
                        code[0] = "A"
                    elif (code[1] == "_") :
                        code[1] = "A"

                elif x >= 175 and x <= 205 and y >= 0 and y <= 30:
                    print("B")
                    print(code[0] + code[1])
                    if (code[0] == "_") :
                        code[0] = 'B'
                    elif (code[1] == "_") :
                        code[1] = 'B'

                elif x >= 105 and x <= 135 and y >= 80 and y <= 115:
                    print("1")
                    print(code[0] + code[1])
                    if (code[0] == "_") :
                        code[0] = "1"
                    elif (code[1] == "_") :
                        code[1] = "1"

                elif x >= 105 and x <= 135 and y >= 0 and y <= 30:
                    print("2")
                    print(code[0] + code[1])
                    if (code[0] == "_") :
                        code[0] = "2"
                    elif (code[1] == "_") :
                        code[1] = "2"

                elif x >= 10 and x <= 75 and y >= 80 and y <= 115:
                    code = ["_", "_"]
                    print("CLR")

                elif x >= 10 and x <= 75 and y >= 0 and y <= 30:
                    if code[0] == "A":
                        if code[1] == "1":
                            message = "This prize is " + str(cost[0]) + " tickets"
                            state = 2
                            item = 1
                        if code[1] == "2":
                            message = "This prize is " + str(cost[1]) + " tickets"
                            state = 2
                            item = 2

                    if code[0] == "B":
                        if code[1] == "1":
                            message = "This prize is " + str(cost[2]) + " tickets"
                            state = 2
                            item = 3
                        if code[1] == "2":
                            message = "This prize is " + str(cost[3]) + " tickets"
                            state = 2
                            item = 4

                    if state != 2:
                        state = 0
                    else:
                        state2start = time.time()

                    code = ["_", "_"]
                    print("SEL")
    
    # Render
    screen.blit(pygame.transform.rotate(screen, 180), (0, 0))
    clock.tick(30)
    pygame.display.flip()

# Close program
print("time out")
GPIO.cleanup() 
sys.exit()